package basic;

import java.util.Arrays;
import java.util.List;

/**
 * @author Cheng Jun
 * @version 1.0
 * Description: 学习数组
 * Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。
 * @date 2019/10/15 13:41
 */
public class ArrayStudy {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3};
        int[] numbers12 = new int[5];
        int length = numbers.length;
        String toString = numbers.toString();
        int[] clone = numbers.clone();
        System.out.println(numbers);
        System.out.println(clone);
        List<int[]> intList = Arrays.asList(numbers);
        // intList.toArray()

        Integer[] numbers1 = {4, 5, 6};
        List<Integer> integerList = Arrays.asList(numbers1);
        //java.lang.UnsupportedOperationException
        // integerList.remove(0);
        // integerList.add(7);
        numbers1[0] = 8;
        integerList.forEach(number -> System.out.println(number));


        // 数组排序
        int[] salary = new int[]{1, 3, 2, 4};
        // stream 流式操作，返回一个新的已经排序的数组
        int[] sortedSalary = Arrays.stream(salary).sorted().toArray();
        for (int item : sortedSalary) {
            System.out.println(item);
        }
        for (int item : salary) {
            System.out.println(item);
        }
        //默认值为 '' ,是'\u0000'（空字符）。
        char[] chars = new char[8];
        for (char aChar : chars) {
            System.out.println(aChar);
        }

        // 注意 boxed 是将基本类型 装箱为 对象类型，mapToInt 是将对象类型 拆箱为基本类型
        // int[] descSalary = Arrays.stream(salary).boxed().sorted((v1, v2) -> v2 - v1).mapToInt(Integer::intValue).toArray();
        // for (int item : descSalary) {
        //     System.out.println(item);
        // }

        // 对 salary 数组进行排序，在salary 数组上进行改变
        // Dual-Pivot Quicksort 双轴快速排序，暂不做研究
        // Arrays.sort(salary);
        // for (int item : salary) {
        //     System.out.println(item);
        // }

        // 编译不通过，Comparator<T> 的 泛型 T 必须是对象
        // Arrays.sort(salary, (v1, v2)-> v1 - v2);

        // Integer[] salary1 = new Integer[]{1, 3, 2, 4};
        // // 逆序
        // Arrays.sort(salary1, Comparator.comparingInt(Integer::intValue).reversed());
        // for (Integer integer : salary1) {
        //     System.out.println(integer);
        // }
        // Arrays.sort(salary1, (v1, v2)-> v2 - v1);

        // Arrays.copyOf 浅copy
        int[] src = new int[]{1, 2, 3};
        int[] dest = Arrays.copyOf(src, src.length);
        dest[0] = 10;
        System.out.println(src.toString());

        int[][] testSort = new int[][]{{0, 2}, {1, 1}, {0, 1}, {1, 2}};
        Arrays.sort(testSort, (a, b) -> {
            if (a[0] != b[0]) {
                return a[0] - b[0];
            } else {
                return a[1] - b[1];
            }
        });
        // 简化上面的排序
        Arrays.sort(testSort, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
        for (int[] ints : testSort) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }

}
